home *** CD-ROM | disk | FTP | other *** search
/ .net 2002 March / DotNetMagazine-Issue107-Coverdisc-NET107-02-03-PCMac.bin / pc / PC Software / picks / HTTrack / httrack-3.22-3.exe / {app} / src_win / WinHTTrack / EasyDropTarget.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-08  |  7.2 KB  |  301 lines
  1. /*
  2.   Implementation example:
  3.   
  4.   1. In the .h file: add
  5.  
  6. #include "EasyDropTarget.h"
  7. ...
  8. private: 
  9.   CEasyDropTarget* drag;
  10. ...
  11.   // Generated message map functions
  12.   afx_msg LRESULT DragDropText(WPARAM wParam,LPARAM lParam);
  13. ...
  14.  
  15.   2. In the cpp file: add
  16.  
  17. #include "EasyDropTarget.h"
  18. ...
  19. #define wm_CEasyDropTargetCallback (WM_USER + 1)
  20. BEGIN_MESSAGE_MAP(Wid1, CDialog)
  21. ...
  22.   ON_MESSAGE( wm_CEasyDropTargetCallback, DragDropText)
  23. ...
  24. END_MESSAGE_MAP()
  25.  
  26.  
  27. ...
  28. int CMyDialogClass::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  29. ...
  30.   // Drag&Drop
  31.   drag=new CEasyDropTarget(this);
  32.   if (drag->IsRegistered()) {
  33.     drag->SetTextCallback(wm_CEasyDropTargetCallback);
  34.   }
  35. ...
  36. }
  37.  
  38.   2b. Add the callback function
  39.  
  40. // Message from CEasyDropTarget
  41. LRESULT CMyDialogClass::DragDropText(WPARAM wParam,LPARAM lParam) {
  42.   if (lParam) {
  43.     CString st=*((CString*) lParam);
  44.     CLIPFORMAT cfFormat=wParam;
  45.     if (cfFormat==CF_TEXT)
  46.       AfxMessageBox("Raw text : "+st);
  47.     else if (cfFormat==CF_HDROP)
  48.       AfxMessageBox("File list (dropped) : "+st);
  49.     else
  50.       AfxMessageBox("Unknown source : "+st);
  51.   }
  52.   return 0;
  53. }
  54.  
  55.  
  56.  
  57.  
  58. */
  59.  
  60. // CEasyDropTarget.cpp : implementation file
  61. //
  62.  
  63. #include "stdafx.h"
  64. #include "Shell.h"
  65. #include "EasyDropTarget.h"
  66. #include <afxole.h>
  67.  
  68. #ifdef _DEBUG
  69. #define new DEBUG_NEW
  70. #undef THIS_FILE
  71. static char THIS_FILE[] = __FILE__;
  72. #endif
  73.  
  74. /////////////////////////////////////////////////////////////////////////////
  75. // CEasyDropTarget
  76. CEasyDropTarget::CEasyDropTarget() {
  77.   this->registered=false;
  78.   //
  79.   this->wnd=NULL;
  80.   this->cedt_text=0;
  81. }
  82.  
  83. CEasyDropTarget::CEasyDropTarget(CWnd* wnd) {
  84.   this->wnd=wnd;
  85.   if (this->wnd) {
  86.     if (Register(this->wnd)) {
  87.       registered=true;
  88.     }
  89.   }
  90. }
  91.  
  92. void CEasyDropTarget::SetTextCallback(UINT fnc) {
  93.   cedt_text=fnc;
  94. }
  95.  
  96. BOOL CEasyDropTarget::IsRegistered() {
  97.   return registered;
  98. }
  99.  
  100.  
  101. /////////////////////////////////////////////////////////////////////////////
  102. // CEasyDropTarget - tools functions
  103. // Convert a String to char** (each lines in each char*)
  104. // Return: NULL if error, else a char** (last char* item is NULL)
  105. char** CEasyDropTarget::StringToArray(CString st) {
  106.   char** tab;
  107.   int i;
  108.   int n=2;                        // one line, + null term
  109.   for(i=0;i<st.GetLength();i++)
  110.     if (st[i]=='\n')
  111.       n++;
  112.   tab=(char**) calloc(n,sizeof(char*));
  113.   if (tab) {
  114.     char* buff=(char*) malloc(st.GetLength()+2);
  115.     if (buff) {
  116.       int index=0;
  117.       buff[st.GetLength()]='\0';        // NULL at the end of buff for last line
  118.       tab[index++]=(char*) buff;
  119.       for(i=0;i<st.GetLength();i++) {
  120.         if (st[i]=='\n') {              // next line (next char*)
  121.           buff[i]='\0';
  122.           tab[index++]=(char*) buff+i+1;  // note: avoid \n\r or else there may be problems (empty lines)
  123.         } else if (st[i]=='\r') {     // ignore \r
  124.           buff[i]='\0';
  125.         } else
  126.           buff[i]=st[i];
  127.       }
  128.       tab[index++]=(char*) NULL;
  129.       return tab;
  130.     } else
  131.       free(tab);
  132.   }
  133.   return (char**) NULL;
  134. }
  135. int CEasyDropTarget::ReleaseStringToArray(char** st) {
  136.   free((void*) st[0]);  // char buffer
  137.   free((void*) st);     // char* buffer
  138.   return 1;
  139. }
  140.  
  141.  
  142. /////////////////////////////////////////////////////////////////////////////
  143. // CEasyDropTarget - Drag&Drop functions
  144. void CEasyDropTarget::SendWndText(CString DroppedData,CLIPFORMAT cfFormat) {
  145.   if (wnd) {
  146.     if (this->cedt_text) {
  147.       wnd->SendMessage(this->cedt_text,cfFormat,(long) &DroppedData);      // Send Message
  148.     }
  149.   }
  150. }
  151.  
  152.  
  153. /////////////////////////////////////////////////////////////////////////////
  154. // CEasyDropTarget - Drag&Drop general functions
  155.  
  156. DROPEFFECT CEasyDropTarget::OnDragScroll( CWnd* pWnd, DWORD dwKeyState, CPoint point ) 
  157. {     
  158.     return DROPEFFECT_NONE; 
  159. } 
  160.  
  161. DROPEFFECT CEasyDropTarget::OnDragOver( CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point ) 
  162. { 
  163.     return DROPEFFECT_COPY; 
  164. } 
  165.  
  166. DROPEFFECT CEasyDropTarget::OnDragEnter( CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point ) 
  167. { 
  168.   return DROPEFFECT_COPY; 
  169. } 
  170.  
  171. BOOL CEasyDropTarget::OnDrop( CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point ) 
  172. { 
  173.   COleDataObject *MyObject = pDataObject;  
  174.   CString DroppedData;
  175.   int ntype=DataToString(pDataObject,DroppedData);
  176.   if (ntype) {
  177.     SendWndText(DroppedData,ntype);
  178.   }
  179.   return TRUE; 
  180. } 
  181.  
  182. int CEasyDropTarget::DataToString(COleDataObject* pDataObject,CString &DroppedData) 
  183. { 
  184.   COleDataObject *MyObject = pDataObject; 
  185.   
  186.   // get file refering to clipboard data
  187.   if (pDataObject->IsDataAvailable(CF_TEXT)) {
  188.     CFile *pFile = pDataObject->GetFileData(CF_TEXT);
  189.     if (pFile != NULL) {
  190.       // connect the file to the archive and read the contents
  191.       CArchive ar(pFile, CArchive::load);
  192.       DroppedData=DoImportText(ar);
  193.       ar.Close();
  194.       delete pFile;                   // desalloc
  195.       return CF_TEXT;
  196.     }
  197.   }
  198.   else if (pDataObject->IsDataAvailable(CF_HDROP)) {
  199.     STGMEDIUM StgMedium;
  200.     if (pDataObject->GetData(CF_HDROP, &StgMedium)) {
  201.       if (StgMedium.tymed==TYMED_HGLOBAL) {
  202.         HGLOBAL hGlobal = (HGLOBAL) StgMedium.hGlobal;
  203.         HDROP hDropInfo = (HDROP) hGlobal;
  204.         DroppedData=DoImportFile(hDropInfo);
  205.       }
  206.       ReleaseStgMedium(&StgMedium);        // desalloc
  207.       return CF_HDROP;
  208.     }
  209.   }
  210.   return -1;
  211. } 
  212.  
  213. CString CEasyDropTarget::DoImportText(CArchive &ar)
  214. {
  215.   char szNode[256];
  216.   CString st="";  
  217.   while (ReadString(ar, szNode, sizeof(szNode)) != NULL)
  218.   {
  219.     int cch = strlen(szNode);
  220.     if (cch) {
  221.       szNode[cch] = '\0';
  222.     }
  223.     if (st.GetLength())
  224.       st+="\r\n";
  225.     st+=szNode;
  226.   }
  227.   return st;  
  228. }
  229.  
  230. CString CEasyDropTarget::DoImportFile(HDROP hDropInfo)
  231. {
  232.   CString st="";
  233.   int nf;
  234.   int i;
  235.   nf=DragQueryFile(hDropInfo,0xFFFFFFFF,NULL,0);    // nb of files
  236.   for(i=0;i<nf;i++) {
  237.     char* buff;
  238.     int size;
  239.     size=DragQueryFile(hDropInfo,i,NULL,0);    // buffer size
  240.     if (size>0) {
  241.       size+=16;    // marge de sÈcuritÈ
  242.       buff=(char*) calloc(size,1);
  243.       if (buff) {
  244.         if (DragQueryFile(hDropInfo,i,buff,size)>0) {    // ok copied
  245.           if (st.GetLength())
  246.             st+="\r\n";
  247.           st+=buff;
  248.         }
  249.         free(buff);
  250.       }
  251.     }
  252.   }
  253.   return st;
  254. }
  255.  
  256.  
  257.  
  258. static int ReadString(CArchive& ar, char* pString, int nMaxLen)
  259. {
  260.     int nCount = 0;
  261.     char ch;
  262.     pString[nCount] = (char)0;
  263.     TRY
  264.     {
  265.         do
  266.         {
  267.             ar >> (BYTE&)ch;
  268.  
  269.             // watch out for ^Z (EOF under DOS)
  270.             if (ch == 0x1A)
  271.                 break;
  272.  
  273.             // combine "\r\n" pair into single "\n"
  274.             if (ch == '\n' && nCount != 0 && pString[nCount-1] == '\r')
  275.                 nCount--;
  276.  
  277.             pString[nCount++] = ch;
  278.  
  279.         } while (nCount < nMaxLen-1 && ch != '\n');
  280.     }
  281.     END_TRY
  282.  
  283. #ifdef _OLD
  284.     // insert newline if missing
  285.     if (nCount != 0 && pString[nCount-1] != '\n' && nCount < nMaxLen-1)
  286.         pString[nCount++] = '\n';
  287.     pString[nCount] = (char)0;
  288. #else
  289.     // insert newline if missing
  290.     if (nCount != 0 && pString[nCount-1] != '\n' && nCount < nMaxLen-1)
  291.     {
  292.         if (pString[nCount-1] == '\0')
  293.             pString[nCount-1] = '\n';
  294.         else
  295.             pString[nCount++] = '\n';
  296.     }
  297.     pString[nCount] = (char)0;
  298. #endif
  299.     return nCount;
  300. }
  301.